package cn.tedu.smartos.admin.service.impl;

import cn.tedu.smartos.admin.mapper.AdminMapper;
import cn.tedu.smartos.admin.pojo.dto.*;
import cn.tedu.smartos.admin.pojo.entity.*;
import cn.tedu.smartos.admin.pojo.vo.NoticeVO;
import cn.tedu.smartos.admin.pojo.vo.RegionVO;
import cn.tedu.smartos.admin.service.AdminService;
import cn.tedu.smartos.base.exception.ServiceException;
import cn.tedu.smartos.baseuser.pojo.vo.UserVO;
import cn.tedu.smartos.admin.pojo.vo.VolunteerVO;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

@Slf4j
@Service
public class AdminServiceImpl implements AdminService {
    @Autowired
    private AdminMapper adminMapper;

    /**
     * 获取用户列表
     *
     * @param pageNum  页码
     * @param pageSize 每页记录数
     * @return 用户列表
     */
    @Override
    public PageInfo<UserVO> list(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【用户列表】的请求,参数{},{}",pageNum,pageSize);
        // 使用PageHelper开始分页
        PageHelper.startPage(pageNum, pageSize);
        List<UserVO> userList = adminMapper.list();
        // 使用PageInfo包装分页结果
        return new PageInfo<>(userList);
    }
    /**
     * 获取用户详情
     * @param userId 用户ID
     * @return UserVO 用户详情
     */
    @Override
    public UserVO detail(Long userId) {
        log.debug("开始处理【获取用户详情】的业务，参数：{}", userId);
        UserVO userVO = adminMapper.detail(userId);
        return userVO;
    }
    /**
     * 删除用户
     * @param userIds 用户ID列表
     */
    @Override
    public void delete(List<Long> userIds) {
        log.debug("开始处理【用户删除】的请求,参数{}",userIds);
        if (CollectionUtils.isEmpty(userIds)) {
            throw new IllegalArgumentException("用户ID列表不能为空");
        }
        // 执行批量删除
        Integer rows = adminMapper.deleteAllByIdInBatch(userIds);
        if (rows == 0){
            throw new ServiceException("删除失败或用户不存在");
        }
        if (rows != userIds.size()) {
            throw new ServiceException("部分用户未能删除");
        }
    }
    /**
     * 修改用户信息
     * @param updateParam
     */
    @Override
    public void update(AdminUpdateParam updateParam) {
        log.debug("开始处理【用户信息修改】的请求,参数{}",updateParam);
        // 将参数对象中的属性值复制到Admin对象中
        Admin update = new Admin();
        BeanUtils.copyProperties(updateParam,update);
        update.setUpdateTime(new Date());
        //  调用Mapper执行修改
        Integer rows = adminMapper.update(update);
        if (rows == 0){
            throw new ServiceException("修改失败");
        }
    }
    /**
     * 添加用户或管理员
     * @param addParam
     */
    @Override
    public void add(AdminAddParam addParam) {
        log.debug("开始处理【用户添加】的业务，参数：{}",addParam);
        Admin admin = new Admin();
        BeanUtils.copyProperties(addParam,admin);
        admin.setPermission("0"); // 设置默认权限
        admin.setRegisterTime(new Date());
        admin.setUpdateTime(new Date());
        Integer rows = adminMapper.insert(admin);
        if (rows != 1){
            throw new ServiceException("添加失败");
        }
    }
    @Override
    public void resetPassword(Long userId) {
        log.debug("开始处理【重置密码】的业务，参数：{}", userId);

        if (userId == null) {
            throw new IllegalArgumentException("用户ID不能为空");
        }

        // 创建更新对象
        Admin update = new Admin();
        update.setUserId(userId);
        update.setPassword("123456"); // 默认密码
        update.setUpdateTime(new Date());

        // 调用Mapper执行更新
        Integer rows = adminMapper.update(update);

        if (rows != 1) {
            throw new ServiceException("重置密码失败，用户可能不存在");
        }

        log.debug("密码重置成功，用户ID：{}", userId);
    }

//—————————————————————————————————————————————————————————————————————————————

    /**
     * 查询所有志愿者
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public PageInfo<VolunteerVO> volunteerList(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【查询所有志愿者】的请求,参数{},{}",pageNum,pageSize);
        // 使用PageHelper开始分页
        PageHelper.startPage(pageNum, pageSize);
        List<VolunteerVO> volunteerVOS = adminMapper.volunteerList();
        // 使用PageInfo包装分页结果
        return new PageInfo<>(volunteerVOS);
    }
    /**
     * 查询待自己审核的志愿者
     *
     * @param auditAdminId 审核管理员ID
     * @param pageNum      页码
     * @param pageSize     每页条数
     * @return 待审核的志愿者列表
     */
    @Override
    public PageInfo<VolunteerVO> waitAudit(Long auditAdminId, Integer pageNum, Integer pageSize) {
        log.debug("开始处理【查询待自己审核的志愿者】的请求,参数{},{},{}",auditAdminId,pageNum,pageSize);
        // 使用PageHelper开始分页
        PageHelper.startPage(pageNum, pageSize);
        List<VolunteerVO> volunteerVOS = adminMapper.waitAudit(auditAdminId);
        return new PageInfo<>(volunteerVOS);
    }
    /**
     * 审核志愿者
     *
     * @param auditParam 审核参数
     */
    @Override
    public void audit(VolunteerAuditParam auditParam) {
        log.debug("开始处理【审核志愿者】的请求,参数{}",auditParam);
        Volunteer audit = new Volunteer();
        BeanUtils.copyProperties(auditParam, audit);
        audit.setAuditTime(new Date());
        Integer rows = adminMapper.auditVolunteer(audit);
        if (rows != 1) {
            throw new ServiceException("审核数据出错");
        }
    }

    /**
     * 查看志愿者详情信息
     * @param userId
     * @return
     */
    @Override
    public VolunteerVO volunteerDetail(Long userId) {
        log.debug("开始处理【查看志愿者详情】的请求,参数{}",userId);
        VolunteerVO volunteerVO = adminMapper.volunteerDetail(userId);
        return volunteerVO;
    }

//——————————————————————————————————————————————————————————————————————————————

    /**
     * 所有公告列表
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public PageInfo<NoticeVO> noticeList(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【公告列表】的请求,参数{},{}",pageNum,pageSize);
        PageHelper.startPage(pageNum,pageSize);
        List<NoticeVO> list = adminMapper.noticeList();
        log.debug("查询结果：{}",list);
        return new PageInfo<>(list);
    }

    /**
     * 删除公告
     * @param noticeIds
     */
    @Override
    public void deleteNotice(List<Long> noticeIds) {
        log.debug("开始处理【删除公告】的请求,参数{}",noticeIds);
        if (CollectionUtils.isEmpty(noticeIds)){
            throw new ServiceException("参数noticeIds不能为空");
        }
        //  调用Mapper执行删除
        Integer rows = adminMapper.deleteNotice(noticeIds);
        if (rows == 0){
            throw new ServiceException("删除出错");
        }
        if (rows != noticeIds.size()){
            throw new ServiceException("部分公告删除失败");
        }
    }
    /**
     * 添加公告
     * @param addParam
     */
    @Override
    public void addNotice(NoticeAddParam addParam) {
        log.debug("开始处理【添加公告】的请求,参数{}",addParam);
        // 将参数对象中的属性值复制到Notice对象中
        Notice notice = new Notice();
        BeanUtils.copyProperties(addParam,notice);
        notice.setCreateTime(new Date());
        notice.setUpdateTime(new Date());
        //  调用Mapper执行添加
        Integer rows = adminMapper.insertNotice(notice);
        if (rows != 1){
            throw new ServiceException("添加失败");
        }
    }
    /**
     * 修改公告
     * @param updateParam
     */
    @Override
    public void updateNotice(NoticeUpdateParam updateParam) {
        log.debug("开始处理【修改公告】的请求,参数{}",updateParam);
        //  将参数对象中的属性值复制到Notice对象中
        Notice update = new Notice();
        BeanUtils.copyProperties(updateParam,update);
        update.setUpdateTime(new Date());
        //  调用Mapper执行修改
        Integer rows = adminMapper.updateNotice(update);
        if (rows != 1){
            throw new ServiceException("公告修改失败");
        }
    }
    /**
     * 查看公告详情
     * @param noticeId
     * @return
     */
    @Override
    public NoticeVO noticeDetail(Long noticeId) {
        log.debug("开始处理【查看公告详情】的请求,参数{}",noticeId);
        if (noticeId == null){
            throw new ServiceException("参数noticeId不能为空");
        }
        NoticeVO noticeVO = adminMapper.noticeDetail(noticeId);
        return noticeVO;
    }

//——————————————————————————————————————————————————————————————————————————————

    /**
     * 区域列表
     * @param pageNum 页码
     * @param pageSize 每页记录数
     * @return 区域列表
     */
    @Override
    public PageInfo<RegionVO> regionList(Integer pageNum, Integer pageSize) {
        log.debug("开始处理【区域列表】的请求,参数{},{}",pageNum,pageSize);
        PageHelper.startPage(pageNum,pageSize);
        List<RegionVO> regionVOS = adminMapper.regionList();
        return new PageInfo<>(regionVOS);
    }
    /**
     * 添加区域
     * @param addParam 区域参数
     */
    @Override
    public void addRegion(RegionParam addParam) {
        log.debug("开始处理【添加区域】的请求,参数{}",addParam);
        //  将参数对象中的属性值复制到Region对象中
        Region region = new Region();
        BeanUtils.copyProperties(addParam,region);
        region.setCreateTime(new Date());
        //  调用Mapper执行添加
        Integer rows = adminMapper.insertRegion(region);
        if (rows != 1){
            throw new ServiceException("区域添加失败");
        }
    }
    /**
     * 删除区域
     * @param regionIds 区域ID列表
     */
    @Override
    public void deleteRegion(List<Integer> regionIds) {
        log.debug("开始处理【删除区域】的请求,参数{}",regionIds);
        if (CollectionUtils.isEmpty(regionIds)){
            throw new ServiceException("参数regionIds不能为空");
        }
        //  调用Mapper执行删除
        Integer rows = adminMapper.deleteRegion(regionIds);
        if (rows == 0){
            throw new ServiceException("删除出错");
        }
        if (rows != regionIds.size()){
            throw new ServiceException("部分区域删除失败");
        }
    }
    /**
     * 查看区域详情
     * @param regionId 区域ID
     * @return 区域详情
     */
    @Override
    public RegionVO regionDetail(Integer regionId) {
        log.debug("开始处理【查看区域详情】的业务，参数：{}", regionId);
        RegionVO regionVO = adminMapper.regionDetail(regionId);
        return regionVO;
    }

    /**
     * 绑定管理员到区域
     * @param adminId 管理员ID
     * @param regionId 区域ID
     */
    @Override
    public void adminBind(Long adminId, Integer regionId) {
        log.debug("开始处理【绑定管理员到区域】的请求,参数{},{}",adminId,regionId);
        if (adminId == null || regionId == null){
            throw new ServiceException("参数不能为空");
        }
        //  创建AdminRegion对象
        AdminRegion adminRegion = new AdminRegion();
        adminRegion.setAdminId(adminId);
        adminRegion.setRegionId(regionId);
        adminRegion.setCreateTime(new Date());
        //  调用Mapper执行插入
        Integer rows = adminMapper.insertAdminRegion(adminRegion);
        if (rows != 1){
            throw new ServiceException("绑定失败");
        }
    }
    /**
     * 解绑管理员与区域
     * @param adminRegionId
     */
    @Override
    public void adminUnbind(Long adminRegionId) {
        log.debug("开始处理【解绑管理员与区域】的请求,参数{}",adminRegionId);
        if (adminRegionId == null){
            throw new ServiceException("参数不能为空");
        }
        Integer rows = adminMapper.deleteAdminRegion(adminRegionId);
        if (rows != 1){
            throw new ServiceException("解绑失败");
        }
    }
}
